home *** CD-ROM | disk | FTP | other *** search
/ START Magazine / START VOL 4 NO 4.st / JULIA.ARC / JULIA.C next >
Encoding:
C/C++ Source or Header  |  1985-11-20  |  6.3 KB  |  284 lines
  1. /* julia:    Buttonless drawing program for children
  2.  * phil comeau 19-sep-87
  3.  * last edited 23-feb-89
  4.  * Copyright 1989 Antic Publishing
  5.  */
  6.  
  7. #include <stdio.h>
  8. #include <portab.h>
  9. #include <gemdefs.h>
  10. #include <osbind.h>
  11.  
  12. #define MAXPITCH 4095            /* highest pitch value used */
  13. #define COLORCYCLE 1000            /* controls rate that we cycle
  14.                      * through palette
  15.                      */
  16. #define LOW8(w) ((w) & 0xff)        /* extract low/hi 8 bits from word */
  17. #define HI8(w) (((w) >> 8) & 0xff)
  18. #define CH_A_PITCH_LOW 1        /* indexes of ch A pitch values in */
  19. #define CH_A_PITCH_HI 3            /* sound program
  20.                      */
  21. #define EXITKEY '\003'            /* <ctrl/C> */
  22. #define ERASEKEY '\005'            /* <ctrl/e> */
  23. #define PARENTKEY '\020'        /* <ctrl/p> */
  24. #define HIDECURSOR 0            /* cursconf() function */
  25. #define MAXCHAR ('~' - ' ')        /* # of character values */
  26. #define CPITCH 120            /* natural note pitches */
  27. #define DPITCH 107
  28. #define EPITCH 95
  29. #define FPITCH 90
  30. #define GPITCH 80
  31. #define APITCH 71
  32. #define BPITCH 64
  33.  
  34. /* Globals used by VDI */
  35. int work_in[11];
  36. int work_out[57];
  37. int contrl[12];
  38. int intin[128];
  39. int ptsin[128];
  40. int intout[128];
  41. int ptsout[128];
  42.  
  43. struct keyPitch {
  44.     char c;                /* keyboard character */
  45.     int pitch;            /* corresponding pitch */
  46. };
  47.  
  48. /* Table of pitches corresponding to notes in the C-major scale. Rows
  49.  * of the keyboard are mapped onto "white piano keys."
  50.  */
  51. struct keyPitch keyTbl[] = {
  52.     {'z', CPITCH * 8},
  53.     {'x', DPITCH * 8},
  54.     {'c', EPITCH * 8},
  55.     {'v', FPITCH * 8},
  56.     {'b', GPITCH * 8},
  57.     {'n', APITCH * 8},
  58.     {'m', BPITCH * 8},
  59.     {',', CPITCH * 4},
  60.     {'.', DPITCH * 4},
  61.     {'/', EPITCH * 4},
  62.     {'a', CPITCH * 4},
  63.     {'s', DPITCH * 4},
  64.     {'d', EPITCH * 4},
  65.     {'f', FPITCH * 4},
  66.     {'g', GPITCH * 4},
  67.     {'h', APITCH * 4},
  68.     {'j', BPITCH * 4},
  69.     {'k', CPITCH * 2},
  70.     {'l', DPITCH * 2},
  71.     {';', EPITCH * 2},
  72.     {'\'', FPITCH * 2},
  73.     {'q', CPITCH * 2},
  74.     {'w', DPITCH * 2},
  75.     {'e', EPITCH * 2},
  76.     {'r', FPITCH * 2},
  77.     {'t', GPITCH * 2},
  78.     {'y', APITCH * 2},
  79.     {'u', BPITCH * 2},
  80.     {'i', CPITCH * 1},
  81.     {'o', DPITCH * 1},
  82.     {'p', EPITCH * 1},
  83.     {'[', FPITCH * 1},
  84.     {']', GPITCH * 1},
  85.     {'\033', CPITCH * 1},
  86.     {'1', DPITCH * 1},
  87.     {'2', EPITCH * 1},
  88.     {'3', FPITCH * 1},
  89.     {'4', GPITCH * 1},
  90.     {'5', APITCH * 1},
  91.     {'6', BPITCH * 1},
  92.     {'7', CPITCH / 2},
  93.     {'8', DPITCH / 2},
  94.     {'9', EPITCH / 2},
  95.     {'0', FPITCH / 2},
  96.     {'-', GPITCH / 2},
  97.     {'=', APITCH / 2},
  98.     {'`', BPITCH / 2},
  99.     {'\b', CPITCH / 4}
  100. };
  101.  
  102. main()
  103. {
  104.     int handle, x, y, lastX, lastY, junk, pxy[4], maxX, midX,
  105.         kbRate, i, cycle, color, openVWk(), ncolors;
  106.     BOOLEAN done, found, parentMode;
  107.     char c;
  108.  
  109.     appl_init();
  110.     handle = openVWk(graf_handle(&junk, &junk, &junk, &junk));
  111.  
  112.     /* Hide the text cursor. */
  113.     Cursconf(HIDECURSOR, 0);
  114.  
  115.     vq_mouse(handle, &junk, &lastX, &lastY);
  116.     srand((long)(lastX * lastY));
  117.  
  118.     /* Determine screen dimensions. */
  119.     switch (Getrez()) {
  120.     case 0:
  121.         maxX = 320;
  122.         ncolors = 16;
  123.         break;
  124.     case 1:
  125.         maxX = 640;
  126.         ncolors = 4;
  127.         break;
  128.     case 2:
  129.         maxX = 640;
  130.         ncolors = 2;
  131.         break;
  132.     }
  133.     midX = maxX / 2;
  134.  
  135.     /* Change the keyboard repeat characteristics so keys repeat
  136.      * as slowly as possible.
  137.      */
  138.     kbRate = Kbrate(0xff, 0xff);
  139.  
  140.     done = parentMode = FALSE;
  141.     cycle = 0;
  142.     color = 1;
  143.     while (!done) {
  144.  
  145.         /* Obtain the current mouse position. */
  146.         vq_mouse(handle, &junk, &x, &y);
  147.  
  148.         if (x != lastX || y != lastY) {
  149.  
  150.             /* The mouse moved. Draw a line from its last
  151.              * location to the current location.
  152.              */
  153.             v_hide_c(handle);
  154.             pxy[0] = lastX;
  155.             pxy[1] = lastY;
  156.             pxy[2] = x;
  157.             pxy[3] = y;
  158.             v_pline(handle, 2, pxy);
  159.             v_show_c(handle, 0);
  160.             lastX = x;
  161.             lastY = y;
  162.  
  163.             /* Make a sound with frequency related to x
  164.              * position. Note that the pitch value varies
  165.              * proportionally with frequency.
  166.              */
  167.             makeSound((int)(MAXPITCH * (long)abs(midX - x) /
  168.                 midX));
  169.         }
  170.  
  171.         /* Check for character presses. */
  172.         if (Cconis()) {
  173.             c = Cnecin();
  174.             if (c == EXITKEY) {
  175.                 done = TRUE;
  176.             }
  177.             else if (c == ERASEKEY) {
  178.                 v_clrwk(handle);
  179.             }
  180.             else if (c == PARENTKEY && parentMode == FALSE) {
  181.                 parentMode = TRUE;
  182.             }
  183.             else if (c == PARENTKEY && parentMode == TRUE) {
  184.                 parentMode = FALSE;
  185.             }
  186.             else if (c == ' ' && parentMode) {
  187.                 v_clrwk(handle);
  188.             }
  189.             else {
  190.                 /* See if the key exists in the keyboard
  191.                  * pitch table.
  192.                  */
  193.                 found = FALSE;
  194.                 for (i = 0; i < sizeof(keyTbl) /
  195.                     sizeof(struct keyPitch) && !found; ++i) {
  196.                     if (keyTbl[i].c == c) {
  197.                         makeSound(keyTbl[i].pitch);
  198.                         found = TRUE;
  199.                     }
  200.                 }
  201.                 if (!found) {
  202.                     makeSound(abs(rand()) % MAXPITCH);
  203.                 }
  204.             }
  205.         }
  206.  
  207.         /* See if it's time to change colors. */
  208.         if (++cycle == COLORCYCLE) {
  209.  
  210.             /* Select the next color from the palette. We'll
  211.              * skip color 0 because it's usually white and
  212.              * therefore invisible.
  213.              */
  214.             color = color % (ncolors - 1) + 1;
  215.             vsl_color(handle, color);
  216.             cycle = 0;
  217.         }
  218.     }
  219.  
  220.  
  221.     /* Restore the keyboard repeat rate. */
  222.     Kbrate(HI8(kbRate), LOW8(kbRate));
  223.  
  224.     clsVWk(handle);
  225.     appl_exit();
  226.     exit(0);
  227. }
  228.  
  229. /* makeSound:    Make a sound with a specified pitch. */
  230.  
  231. makeSound(pitch)
  232. int pitch;
  233. {
  234.     static unsigned char sound[] = {
  235.         0x00, 0x00,        /* ch A pitch low */
  236.         0x01, 0x00,        /* ch A pitch high */
  237.         0x02, 0x00,        /* ch B pitch low */
  238.         0x03, 0x00,        /* ch B pitch high */
  239.         0x04, 0x00,        /* ch C pitch low */
  240.         0x05, 0x00,        /* ch C pitch high */
  241.         0x06, 0x00,        /* noise pitch */
  242.         0x07, 0xfe,        /* mixer: only ch A enabled */
  243.         0x08, 0x10,        /* ch A volume: use envelope */
  244.         0x09, 0x00,        /* ch B volume */
  245.         0x0a, 0x00,        /* ch C volume */
  246.         0x0b, 0x10,        /* sustain low: 10000 (base 10) */
  247.         0x0c, 0x27,        /* sustain high */
  248.         0x0d, 0x09,        /* envelope: decay and hold */
  249.         0xff, 0x00        /* end of sound program */
  250.     };
  251.  
  252.     /* Write the pitch into the tone pitch registers. */
  253.     sound[CH_A_PITCH_LOW] = LOW8(pitch);
  254.     sound[CH_A_PITCH_HI] = HI8(pitch);
  255.     
  256.     /* Play the sound */
  257.  
  258.     Dosound(sound);
  259. }
  260.  
  261. /* openVWk:    Open a virtual workstation */
  262. int openVWk(physHandle)
  263. int physHandle;
  264. {
  265.     register int i;
  266.     int handle;
  267.  
  268.     for (i = 0; i < 10; ++i) {
  269.         work_in[i] = 1;
  270.     }
  271.     work_in[i] = 2;
  272.     handle = physHandle;
  273.     v_opnvwk(work_in, &handle, work_out);
  274.  
  275.     return (handle);
  276. }
  277.  
  278. /* clsVWk:    Close a virtual workstation */
  279. clsVWk(handle)
  280. int handle;
  281. {
  282.     v_clsvwk(handle);
  283. }
  284.